1
2
3
4
Sonraki
İndexOf kullanarak kaldırmak istediğiniz dizi öğesinin dizinini bulun ve ardından bu dizini ekleme ile kaldırın.
Splice () yöntemi, bir dizinin içeriğini değiştirerek
mevcut öğeler ve / veya yeni öğeler eklenmesi.
const dizi = [2, 5, 9];
console.log (dizi);
const dizin = dizi.indexOf (5);
eğer (dizin> -1) {
dizi.splice (dizin, 1);
}
// dizi = [2, 9]
console.log (dizi);
Eklemenin ikinci parametresi, kaldırılacak öğelerin sayısıdır. Splice'ın diziyi yerinde değiştirdiğini ve kaldırılan öğeleri içeren yeni bir dizi döndürdüğünü unutmayın.
Tamlık açısından işte fonksiyonlar. İlk işlev yalnızca tek bir oluşumu kaldırır (yani [2,5,9,1,5,8,5] 'den ilk 5 eşleşmesini kaldırırken), ikinci işlev tüm oluşumları kaldırır:
function removeItemOnce (dizi, değer) {
var indeksi = arr.indexOf (değer);
eğer (dizin> -1) {
arr.splice (dizin, 1);
}
dönüş arr;
}
function removeItemAll (dizi, değer) {
var i = 0;
while (i = 0; i--) {
eğer (dizi [i] === sayı) {
dizi.splice (i, 1);
}
}
Sadece i indeksindeki öğeyi yapmak istiyorsanız, ancak diğer öğelerin indekslerinin değişmesini istemiyorsanız:
[i] dizisini sil;
|
Ekim 2016'da düzenlendi
Basit, sezgisel ve açık bir şekilde yapın (Occam'ın usturası)
Değişmez yapın (orijinal dizi değişmeden kalır)
Tarayıcınız desteklemiyorsa standart JavaScript işlevleriyle yapın - polyfill kullanın
Bu kod örneğinde, bir diziden istenmeyen öğeleri kaldırmak için "array.filter (...)" işlevini kullanıyorum. Bu işlev orijinal diziyi değiştirmez ve yeni bir tane oluşturur. Tarayıcınız bu işlevi desteklemiyorsa (örneğin, sürüm 9'dan önceki Internet Explorer veya sürüm 1.5'ten önceki Firefox), Mozilla'dan çoklu dolgu filtresini kullanmayı düşünün.
Öğeyi kaldırma (ECMA-262 Sürüm 5 kodu, yani eski stil JavaScript)
var değer = 3
var arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (function (öğe) {
iade öğesi! == değer
})
console.log (arr)
// [1, 2, 4, 5]
Öğe kaldırılıyor (ECMAScript 6 kodu)
let değer = 3
let arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (öğe => öğe! == değer)
console.log (arr)
// [1, 2, 4, 5]
ÖNEMLİ ECMAScript 6 "() => {}" ok işlevi sözdizimi, Internet Explorer'da, 45 sürümünden önceki Chrome'da, 22 sürümünden önceki Firefox sürümünde ve 10 sürümden önceki Safari'de hiç desteklenmemektedir. ECMAScript 6 sözdizimini eski tarayıcılarda kullanmak için BabelJS'yi kullanabilirsiniz.
Birden çok öğeyi kaldırma (ECMAScript 7 kodu)
Bu yöntemin ek bir avantajı, birden çok öğeyi kaldırabilmenizdir.
let forDeletion = [2, 3, 5]
let arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (öğe =>! forDeletion.includes (öğe))
// !!! Array.includes (...) desteği hakkında aşağıda okuyun !!!
console.log (arr)
// [1, 4]
ÖNEMLİ "array.includes (...)" işlevi Internet Explorer'da, 47 sürümünden önceki Chrome'da, 43 sürümden önceki Firefox'ta, 9 sürümünden önceki Safari ve 14 sürümden önceki Edge'de desteklenmez, bu nedenle Mozilla'dan polyfill burada.
Birden çok öğeyi kaldırma (gelecekte belki)
"This-Binding Syntax" teklifi kabul edilirse, bunu yapabilirsiniz:
// dizi-lib.js
dışa aktarma işlevi remove (... forDeletion) {
this.filter (öğe =>! forDeletion.includes (öğe))
}
// main.js
"./array-lib.js" içinden {remove} dosyasını içe aktarın
let arr = [1, 2, 3, 4, 5, 3]
// :: This-Binding Sözdizimi Önerisi
// "kaldır" işlevini "sanal yöntem" olarak kullanma
// Array.prototype'ı genişletmeden
arr = arr :: remove (2, 3, 5)
console.log (arr)
// [1, 4]
BabelJS'de kendiniz deneyin :)
Referans
Array.prototype.includes
Fonksiyonel kompozisyon
|
Boş bir yer tutmak isteyip istemediğinize bağlıdır.
Boş bir yuva istiyorsanız:
dizi [dizin] = tanımsız;
Boş bir yuva istemiyorsanız:
// Orijinali saklamak için:
// oldArray = [... dizi];
// Bu, diziyi değiştirir.
dizi.splice (dizin, 1);
Ve bu öğenin değerine ihtiyacınız varsa, döndürülen dizinin öğesini saklayabilirsiniz:
var değer = dizi.splice (dizin, 1) [0];
Dizinin iki ucundan birini kaldırmak isterseniz, sonuncusu için array.pop () veya ilkinde array.shift () kullanabilirsiniz (ikisi de öğenin değerini döndürür).
Öğenin dizinini bilmiyorsanız, onu almak için array.indexOf (öğe) 'yi kullanabilirsiniz (bir öğeyi almak için bir if () içinde veya bir süre sonra () hepsini almak için). array.indexOf (öğe), bulunamazsa dizini veya -1 değerini döndürür.
|
Bir arkadaşım Internet Explorer 8'de sorunlar yaşıyordu ve bana ne yaptığını gösterdi. Ona yanlış olduğunu söyledim ve bana cevabı aldığını söylediburaya. Mevcut en iyi cevap tüm tarayıcılarda (örneğin Internet Explorer 8) çalışmayacak ve yalnızca maddenin ilk geçtiği yeri kaldıracaktır.
Bir diziden TÜM örnekleri kaldır
function array_remove_index_by_value (dizi, öğe)
{
for (var i = dizi uzunluk; i--;)
{
eğer (dizi [i] === öğe) {dizi.splice (i, 1);}
}
}
Dizide geriye doğru döner (öğeler çıkarıldıkça indisler ve uzunluk değişeceğinden) ve bulunursa öğeyi kaldırır. Tüm tarayıcılarda çalışır.
|
İki ana yaklaşım vardır:
splice (): anArray.splice (dizin, 1);
delete: anArray [index] 'i sil;
Bir dizi için silme özelliğini kullanırken dikkatli olun. Nesnelerin niteliklerini silmek için iyidir, ancak diziler için o kadar iyi değildir. Diziler için splice kullanmak daha iyidir.
Bir dizi için delete kullandığınızda anArray.length için yanlış sonuçlar alabileceğinizi unutmayın. Başka bir deyişle, silme işlemi öğeyi kaldırır, ancak uzunluk özelliğinin değerini güncellemez.
Ayrıca silmeyi kullandıktan sonra dizin numaralarında delikler olmasını bekleyebilirsiniz, örn. silmeyi kullanmadan önce olduğu gibi 1, 3, 4, 8, 9 ve 11 dizinlerine ve uzunluğa sahip olabilirsiniz. Bu durumda, indeksler artık sıralı olmadığından döngüler için indekslenenlerin tümü çöker.
Herhangi bir nedenle silme işlemini kullanmaya zorlanırsanız, diziler arasında döngü yapmanız gerektiğinde her döngü için kullanmalısınız. İşin doğrusu, mümkünse her zaman için dizine alınmış döngüler kullanmaktan kaçının. Bu şekilde, kod daha sağlam ve dizinlerle ilgili sorunlara daha az eğilimli olacaktır.
|
Array.prototype.remove_by_value = function (val) {
for (var i = 0; i row.id === 5);
var kaldırıldı = helper.remove (arr, row => row.name.startsWith ('BMW'));
##Tanım
var helper = {
// Kaldır ve ilk geçtiği yeri döndür
removeOne: function (dizi, yüklem) {
for (var i = 0; i [2, 3, 4]
|
ES6'yı kullanabilirsiniz. Örneğin, bu durumda '3' değerini silmek için:
var dizi = ['1', '2', '3', '4', '5', '6']
var newArray = array.filter ((değer) => değer! = '3');
console.log (newArray);
Çıktı :
["1", "2", "4", "5", "6"]
|
Silinen konumların kaldırıldığı yeni bir dizi istiyorsanız, her zaman belirli öğeyi silebilir ve diziyi filtreleyebilirsiniz. Filtre yöntemini uygulamayan tarayıcılar için dizi nesnesinin bir uzantısına ihtiyaç duyabilir, ancak uzun vadede daha kolay çünkü tek yaptığınız şudur:
var my_array = [1, 2, 3, 4, 5, 6];
my_array [4] 'ü sil;
console.log (my_array.filter (function (a) {return typeof a! == 'undefined';}));
[1, 2, 3, 4, 6] göstermelidir.
|
JavaScript kullanarak bir diziden bir öğeyi kaldırmanın birkaç yolu.
Açıklanan tüm yöntemler orijinal diziyi değiştirmez ve bunun yerine yeni bir tane oluşturur.
Bir öğenin dizinini biliyorsanız
Bir diziniz olduğunu ve i konumundaki bir öğeyi kaldırmak istediğinizi varsayalım.
Bir yöntem, dilim () kullanmaktır:
const öğeler = ['a', 'b', 'c', 'd', 'e', 'f']
const i = 3
const filteredItems = öğeler.slice (0, i) .concat (öğeler.slice (i + 1, öğeler.uzunluk))
console.log (filteredItems)
slice (), aldığı dizinlerle yeni bir dizi oluşturur. Basitçe, baştan kaldırmak istediğimiz dizine kadar yeni bir dizi oluştururuz ve ilk konumdan kaldırdığımız dizinin sonuna kadar başka bir diziyi birleştiririz.
Eğer değerini biliyorsanız
Bu durumda, iyi bir seçenek, daha bildirime dayalı bir yaklaşım sunan filter () kullanmaktır:
const öğeler = ['a', 'b', 'c', 'd', 'e', 'f']
const valueToRemove = 'c'
const filteredItems = items.filter (öğe => öğe! == valueToRemove)
console.log (filteredItems)
Bu, ES6 ok işlevlerini kullanır. Daha eski tarayıcıları desteklemek için geleneksel işlevleri kullanabilirsiniz:
const öğeler = ['a', 'b', 'c', 'd', 'e', 'f']
const valueToRemove = 'c'
const filteredItems = items.filter (function (öğe) {
iade öğesi! == valueToRemove
})
console.log (filteredItems)
veya Babel'i kullanabilir ve ES6 kodunu eski tarayıcılar için daha sindirilebilir hale getirmek için ES5'e geri aktarabilirsiniz, ancak kodunuza modern JavaScript yazabilirsiniz.
Birden çok öğeyi kaldırma
Ya tek bir öğe yerine çok sayıda öğeyi kaldırmak isterseniz?
En basit çözümü bulalım.
Dizine göre
Sadece bir işlev oluşturabilir ve serideki öğeleri kaldırabilirsiniz:
const öğeler = ['a', 'b', 'c', 'd', 'e', 'f']
const removeItem = (öğeler, i) =>
items.slice (0, i-1) .concat (items.slice (i, items.length))
filteredItems = removeItem (öğeler, 3)
filteredItems = removeItem (filteredItems, 5)
// ["a", "b", "c", "d"]
console.log (filteredItems)
Değere göre
Geri arama işlevi içinde dahil etmeyi arayabilirsiniz:
const öğeler = ['a', 'b', 'c', 'd', 'e', 'f']
const valuesToRemove = ['c', 'd']
const filteredItems = items.filter (öğe =>! valuesToRemove.includes (öğe))
// ["a", "b", "e", "f"]
console.log (filteredItems)
Orijinal diziyi değiştirmekten kaçının
splice () (slice () ile karıştırılmamalıdır) orijinal diziyi değiştirir ve bundan kaçınılmalıdır.
(ilk olarak sitemde yayınlanmıştır https://flaviocopes.com/how-to-remove-item-from-array/)
|
Bu koda bakın. Her büyük tarayıcıda çalışır.
remove_item = function (dizi, değer) {
var b = '';
for (b in arr) {
eğer (dizi [b] === değer) {
arr.splice (b, 1);
kırmak;
}
}
dönüş arr;
};
Bu işlevi çağırın
remove_item (dizi, değer);
|
ES6 ve mutasyonsuz: (Ekim 2016)
const removeByIndex = (liste, dizin) =>
[
... list.slice (0, dizin),
... list.slice (dizin + 1)
];
output = removeByIndex ([33,22,11,44], 1) // => [33,11,44]
console.log (çıktı)
|
Lodash _.pull (mutate array), _.pullAt (mutate array) veya _.without (diziyi değiştirmez) kullanabilirsiniz
var dizi1 = ['a', 'b', 'c', 'd']
_.pull (dizi1, 'c')
console.log (dizi1) // ['a', 'b', 'd']
var dizi2 = ['e', 'f', 'g', 'h']
_.pullAt (dizi2; 0)
console.log (dizi2) // ['f', 'g', 'h']
var dizi3 = ['i', 'j', 'k', 'l']
var newArray = _.without (dizi3, 'i') // ['j', 'k', 'l']
console.log (dizi3) // ['i', 'j', 'k', 'l']
|
Bir diziden belirli bir öğeyi / dizeyi kaldırmak tek satırlık bir şekilde yapılabilir:
theArray.splice (theArray.indexOf ("stringToRemoveFromArray"), 1);
nerede:
theArray: belirli bir şeyi kaldırmak istediğiniz dizi
stringToRemoveFromArray: kaldırılmasını istediğiniz dize ve 1, kaldırmak istediğiniz öğe miktarıdır.
NOT: "StringToRemoveFromArray" dizinizde yer almıyorsa, bu dizinin son öğesini kaldıracaktır.
Kaldırmadan önce öğenin dizinizde olup olmadığını kontrol etmek her zaman iyi bir uygulamadır.
if (theArray.indexOf ("stringToRemoveFromArray")> = 0) {
theArray.splice (theArray.indexOf ("stringToRemoveFromArray"), 1);
}
İstemcinizin bilgisayarlarında daha yeni Ecmascript sürümlerine erişiminiz varsa (UYARI, eski istasyonlarda çalışmayabilir):
var dizi = ['1', '2', '3', '4', '5', '6']
var newArray = array.filter ((değer) => değer! = '3');
'3' diziden kaldırılmasını istediğiniz değerdir.
Dizi daha sonra şöyle olur: ['1', '2', '4', '5', '6']
|
Tamam, örneğin aşağıdaki diziye sahipsiniz:
var num = [1, 2, 3, 4, 5];
Ve 4 numarayı silmek istiyoruz. Aşağıdaki kodu kullanabilirsiniz:
num.splice (num.indexOf (4), 1); // num [1, 2, 3, 5] olacaktır;
Bu işlevi yeniden kullanıyorsanız, aşağıdaki gibi yerel dizi işlevine eklenecek yeniden kullanılabilir bir işlev yazarsınız:
Array.prototype.remove = Array.prototype.remove || function (x) {
const i = this.indexOf (x);
eğer (i === - 1)
dönüş;
this.splice (i, 1); // num.remove (5) === [1, 2, 3];
}
Ama dizide birkaç [5] ile aşağıdaki diziye sahipseniz nasıl olur?
var num = [5, 6, 5, 4, 5, 1, 5];
Hepsini kontrol etmek için bir döngüye ihtiyacımız var, ancak daha kolay ve daha verimli bir yol yerleşik JavaScript işlevlerini kullanmaktır, bu nedenle aşağıdaki gibi bir filtre kullanan bir işlev yazıyoruz:
const _removeValue = (arr, x) => arr.filter (n => n! == x);
// _ removeValue ([1, 2, 3, 4, 5, 5, 6, 5], 5) // Return [1, 2, 3, 4, 6]
Ayrıca Lodash veya Underscore gibi bunu yapmanıza yardımcı olan üçüncü taraf kitaplıkları da vardır. Daha fazla bilgi için lodash _.pull, _.pullAt veya _.without sayfalarına bakın.
|
Verim
Bugün (2019-12-09) Seçilen çözümler için macOS v10.13.6 (High Sierra) üzerinde performans testleri yapıyorum. Silme (A) gösteriyorum, ancak dizide boş alan bıraktığı için diğer yöntemlerle karşılaştırıldığında kullanmıyorum.
Sonuçlar
en hızlı çözüm array.splice (C) 'dir (ikinci kez bulunduğu küçük diziler için Safari hariç)
büyük diziler için, array.slice + splice (H), Firefox ve Safari için en hızlı değişmez çözümdür; Array.from (B), Chrome'da en hızlısıdır
değiştirilebilir çözümler genellikle sabitten 1,5x-6x daha hızlıdır
Safari'deki küçük tablolar için, şaşırtıcı bir şekilde değiştirilebilir çözüm (C), değişmez çözümden (G) daha yavaştır
Detaylar
Testlerde orta elemanı diziden farklı yollarla kaldırırım. A, C çözümleri yerinde. B, D, E, F, G, H çözümleri değişmezdir.
10 öğeli dizi için sonuçlar
Chrome'da array.splice (C) en hızlı yerinde çözümdür. Array.filter (D), değişmez en hızlı çözümdür. En yavaş olan array.slice (F) 'dir. Testi buradan makinenizde gerçekleştirebilirsiniz.
1.000.000 öğeli dizi için sonuçlar
Chrome'da array.splice (C) en hızlı yerinde çözümdür (delete (C) benzer hızlıdır - ancak dizide boş bir yuva bırakmıştır (bu nedenle 'tam kaldırma' gerçekleştirmez). Array.slice-splice (H), değişmez en hızlı çözümdür. En yavaş olan array.filter (D ve E) 'dir. Testi buradan makinenizde gerçekleştirebilirsiniz.
var a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
var log = (letter, array) => console.log (letter, array.join `,`);
function A (dizi) {
var index = array.indexOf (5);
dizi [dizin] sil;
günlük ('A', dizi);
}
function B (dizi) {
var index = array.indexOf (5);
var dizi = Array.from (dizi);
arr.splice (dizin, 1)
log ('B', dizi);
}
function C (dizi) {
var index = array.indexOf (5);
dizi.splice (dizin, 1);
günlük ('C', dizi);
}
function D (dizi) {
var arr = array.filter (öğe => öğe! == 5)
günlük ('D', dizi);
}
function E (dizi) {
var index = array.indexOf (5);
var arr = dizi.filter ((öğe, i) => i! == dizin)
log ('E', dizi);
}
function F (dizi) {
var index = array.indexOf (5);
var arr = dizi.slice (0, dizin) .concat (dizi.slice (dizin + 1))
log ('F', dizi);
}
function G (dizi) {
var index = array.indexOf (5);
var dizi = [... dizi.slice (0, dizin), ... dizi.slice (dizin + 1)]
log ('G', dizi);
}
function H (dizi) {
var index = array.indexOf (5);
var dizi = dizi.slice (0);
arr.splice (dizin, 1);
log ('H', dizi);
}
A ([... a]);
B ([... a]);
CA]);
D ([... a]);
E ([... a]);
F ([... a]);
G ([... a]);
Ha]);
Bu kod parçası yalnızca performans testlerinde kullanılan kodu sunar - testleri kendi başına gerçekleştirmez.
Tarayıcılar için karşılaştırma: Chrome v78.0.0, Safari v13.0.4 ve Firefox v71.0.0
|
JavaScript konusunda oldukça yeniyim ve bu işleve ihtiyacım vardı. Ben sadece şunu yazdım:
function removeFromArray (dizi, öğe, dizin) {
while ((dizin = dizi.indexOf (öğe))> -1) {
dizi.splice (dizin, 1);
}
}
Sonra onu kullanmak istediğimde:
// Bazı sahte verileri ayarlayın
var dummyObj = {isim: "miyav"};
var dummyArray = [dummyObj, "öğe1", "öğe1", "öğe2"];
// Sahte verileri kaldırın
removeFromArray (dummyArray, dummyObj);
removeFromArray (dummyArray, "öğe2");
Çıktı - Beklendiği gibi.
["öğe1", "öğe1"]
Benden farklı ihtiyaçlarınız olabilir, böylece onu kolayca değiştirebilirsinizonlara uyacak şekilde. Umarım bu birine yardımcı olur.
|
Dizide karmaşık nesneleriniz varsa filtreleri kullanabilirsiniz?
$ .İnArray veya array.splice'ın kullanımının o kadar kolay olmadığı durumlarda. Özellikle nesneler dizide sığ ise.
Örneğin. Kimlik alanına sahip bir nesneniz varsa ve nesnenin bir diziden kaldırılmasını istiyorsanız:
this.array = this.array.filter (function (element, i) {
return element.id! == idToRemove;
});
|
ECMAScript 6'ya göre cevaplamak istiyorum. Aşağıdaki gibi bir diziniz olduğunu varsayalım:
let dizi = [1,2,3,4];
2 gibi özel bir dizinden silmek isterseniz aşağıdaki kodu yazınız:
arr.splice (2, 1); // => arr, [1,2,4] oldu
Ancak 3 gibi özel bir öğeyi silmek istiyorsanız ve indeksini bilmiyorsanız, aşağıdaki gibi yapın:
arr = arr.filter (e => e! == 3); // => arr, [1,2,4] oldu
İpucu: Boş bir dizi elde etmediğiniz sürece lütfen filtre geri çağrısı için bir ok işlevi kullanın.
|
Güncelleme: Bu yöntem yalnızca ECMAScript 2015'i (eski adıyla ES6) kullanamıyorsanız önerilir. Kullanabiliyorsanız, buradaki diğer cevaplar çok daha düzgün uygulamalar sağlar.
Buradaki öz, probleminizi çözecek ve ayrıca sadece 1 (veya belirli bir değer) yerine argümanın tüm oluşumlarını siler.
Array.prototype.destroy = function (obj) {
// Hiçbir nesne bulunamazsa ve kaldırılmazsa boş döndürür
var destroyed = null;
for (var i = 0; i 3
x.destroy (yanlış); // => yanlış
x; // => [1, 2, doğru, tanımsız]
x.destroy (doğru); // => doğru
x.destroy (tanımsız); // => tanımsız
x; // => [1, 2]
x.destroy (3); // => boş
x; // => [1, 2]
|
ES10 Güncellemesi
Bu gönderi, ECMAScript 2019 (ES10) itibarıyla diziden öğe kaldırmaya yönelik yaygın yaklaşımları özetlemektedir.
1. Genel durumlar
1.1. Array öğesini .splice () kullanarak değere göre kaldırma
| Yerinde: Evet |
| Yinelenenleri kaldırır: Evet (döngü), Hayır (indexOf) |
| Değere / dizine göre: Dizine göre |
Bir diziden kaldırmak istediğiniz değeri biliyorsanız, splice yöntemini kullanabilirsiniz. Önce hedef öğenin dizinini belirlemelisiniz. Daha sonra dizini başlangıç öğesi olarak kullanır ve yalnızca bir öğeyi kaldırırsınız.
// Bir 'for' döngüsü ile
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
for (let i = 0; i [1, 2, 3, 4, 6, 7, 8, 9, 0]
// .indexOf () yöntemiyle
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
const i = dizi.indexOf (5);
arr.splice (i, 1); // => [1, 2, 3, 4, 6, 7, 8, 9, 0]
1.2. .Filter () yöntemini kullanarak Dizi öğesini kaldırma
| Yerinde: Hayır |
| Yinelenenleri kaldırır: Evet |
| Değere / endekse göre: Değere göre |
Filtreleme işlevi sağlanarak belirli eleman diziden filtrelenebilir. Böyle bir işlev daha sonra dizideki her eleman için çağrılır.
sabit değer = 3
let arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (öğe => öğe! == değer)
console.log (arr)
// [1, 2, 4, 5]
1.3. Array.prototype'ı genişleterek Array öğesini kaldırma
| Yerinde: Evet / Hayır (Uygulamaya bağlıdır) |
| Yinelenenleri kaldırır: Evet / Hayır (Uygulamaya bağlıdır) |
| Değere / dizine göre: Dizine göre / Değere göre (Uygulamaya bağlıdır) |
Prototype of Array ek yöntemlerle genişletilebilir. Bu tür yöntemler daha sonra oluşturulan dizilerde kullanılabilir olacaktır.
Not: Nesnelerin prototiplerini standart JavaScript kitaplığından (Array gibi) genişletmek, bazıları tarafından bir anti-model olarak kabul edilir.
// Yerinde, değer uygulamasına göre hepsini kaldırır
Array.prototype.remove = function (öğe) {
for (let i = 0; i = ES10)
| Yerinde: Hayır |
| Yinelenenleri kaldırır: Evet |
| Değere / endekse göre: Değere göre |
ES10, Object.fromEntries'i tanıttı.herhangi bir Dizi benzeri nesneden istenen Dizi oluşturmak ve işlem sırasında istenmeyen öğeleri filtrelemek için kullanılır.
const nesne = [1,2,3,4];
const valueToRemove = 3;
const arr = Object.values (Object.fromEntries (
Object.entries (nesne)
.filter (([anahtar, val]) => val! == valueToRemove)
));
console.log (arr); // [1,2,4]
2. Özel durumlar
2.1 Dizinin sonundaysa öğeyi kaldırma
2.1.1. Dizi uzunluğunu değiştirme
| Yerinde: Evet |
| Yinelenenleri kaldırır: Hayır |
| Değere / endekse göre: N / A |
JavaScript Dizi öğeleri, length özelliği geçerli değerden daha düşük bir değere ayarlanarak bir dizinin sonundan kaldırılabilir. Dizini yeni uzunluğa eşit veya daha büyük olan herhangi bir öğe kaldırılacaktır.
const arr = [1, 2, 3, 4, 5, 6];
arr.length = 5; // Öğeyi kaldırmak için uzunluğu ayarlayın
console.log (arr); // [1, 2, 3, 4, 5]
2.1.2. .Pop () yöntemini kullanma
| Yerinde: Evet |
| Yinelenenleri kaldırır: Hayır |
| Değere / endekse göre: N / A |
Pop yöntemi dizinin son öğesini kaldırır, bu öğeyi döndürür ve length özelliğini günceller. Pop yöntemi, çağrıldığı diziyi değiştirir. Bu, silme işleminin aksine, son öğenin tamamen kaldırıldığı ve dizi uzunluğunun azaltıldığı anlamına gelir.
const arr = [1, 2, 3, 4, 5, 6];
arr.pop (); // 6 döndürür
console.log (arr); // [1, 2, 3, 4, 5]
2.2. Dizinin başındaysa öğe kaldırılıyor
| Yerinde: Evet |
| Yinelenenleri kaldırır: Hayır |
| Değere / endekse göre: N / A |
.Shift () yöntemi pop yöntemine çok benzer, tek farkı bir JavaScript dizisinin son öğesi yerine ilk öğesini kaldırmasıdır. Öğe kaldırıldığında, kalan öğeler aşağı kaydırılır.
const arr = [1, 2, 3, 4];
arr.shift (); // 1 döndürür
console.log (arr); // [2, 3, 4]
2.3. Dizideki tek öğeyse öğeyi kaldırma
| Yerinde: Evet |
| Yinelenenleri kaldırır: N / A |
| Değere / endekse göre: N / A |
En hızlı teknik, bir dizi değişkenini boş bir diziye ayarlamaktır.
let dizi = [1];
arr = []; // boş dizi
Uzunluk 0 olarak ayarlanarak alternatif olarak 2.1.1'deki teknik kullanılabilir.
|
Dizinizi asla değiştirmemelisiniz. Çünkü bu, işlevsel programlama modeline aykırıdır. ECMAScript 6 yöntem filtresini kullanarak verilerini değiştirmek istediğiniz diziye başvurmadan yeni bir dizi oluşturabilirsiniz;
var myArray = [1, 2, 3, 4, 5, 6];
Diziden 5'i çıkarmak istediğinizi varsayalım, bunu şu şekilde yapabilirsiniz:
myArray = myArray.filter (değer => değer! == 5);
Bu size kaldırmak istediğiniz değerin olmadığı yeni bir dizi verecektir. Sonuç şu olacak:
[1, 2, 3, 4, 6]; // 5 bu diziden çıkarıldı
Daha fazla bilgi için Array.filter'daki MDN belgelerini okuyabilirsiniz.
|
Daha modern bir ECMAScript 2015 (eski adıyla Harmony veya ES 6) yaklaşımı Verilen:
const öğeler = [1, 2, 3, 4];
const indeksi = 2;
Sonra:
items.filter ((x, i) => i! == dizin);
Verici:
[1, 2, 4]
Bunun tarayıcılarda iyi desteklendiğinden emin olmak için Babel ve bir çoklu doldurma hizmetini kullanabilirsiniz.
|
Öğenin birden çok örneği varsa, dizinleri bozmamak için geriye doğru bir döngü yapabilirsiniz.
var myElement = "çikolata";
var myArray = ['çikolata', 'poptart', 'poptart', 'poptart', 'çikolata', 'poptart', 'poptart', 'çikolata'];
/ * Önemli kod * /
for (var i = myArray.length - 1; i> = 0; i--) {
eğer (myArray [i] == myElement) myArray.splice (i, 1);
}
console.log (myArray);
Canlı Demo
|
Dizide 1'den 9'a kadar var ve 5'i kaldırmak istiyorsunuz. Aşağıdaki kodu kullanın:
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var newNumberArray = numberArray.filter (m => {
dönüş m! == 5;
});
console.log ("yeni Dizi, 5 kaldırıldı", newNumberArray);
Birden çok değer istiyorsanız. Örnek: - 1,7,8
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var newNumberArray = numberArray.filter (m => {
dönüş (m! == 1) && (m! == 7) && (m! == 8);
});
console.log ("yeni Dizi, 1,7 ve 8 kaldırıldı", newNumberArray);
Bir dizideki bir dizi değerini kaldırmak istiyorsanız. Örnek: [3,4,5]
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var removeebleArray = [3,4,5];
var newNumberArray = numberArray.filter (m => {
return! removeebleArray.includes (m);
});
console.log ("yeni Dizi, [3,4,5] kaldırıldı", newNumberArray);
Desteklenen tarayıcı içerir bağlantıdır.
|
1
2
3
4
Sonraki
Oldukça aktif soru. Bu soruyu cevaplamak için 10 itibar kazanın. İtibar koşulu, bu sorunun istenmeyen postalardan ve yanıtlanmayan etkinliklerden korunmasına yardımcı olur.
Aradığın cevap değil mi? Javascript dizileri ile etiketlenmiş diğer sorulara göz atın veya kendi sorunuzu sorun.